﻿///
/// <summary>C# Standard Libarary</summary>
///
#if Sharp
    namespace System
    {
        public class ApplicationException : Exception
        {
            public ApplicationException();
            public ApplicationException(string message);
            public ApplicationException(string message, Exception innerException);
        }
    }
    namespace System
    {
        public class ArgumentException : SystemException
        {
            public ArgumentException();
            public ArgumentException(string message);
            public ArgumentException(string message, Exception innerException);
        }
    }
    namespace System
    {
        public class ArithmeticException : SystemException
        {
            public ArithmeticException();
            public ArithmeticException(string message);
            public ArithmeticException(string message, Exception innerException);
        }
    }
    namespace System
    {
        using Collections;
        public abstract class Array : IList, ICollection, IEnumerable
        {
            public int Length { get; }
            public int Rank { get; }
            public int GetLength(int dimension);
        }
    }
    namespace System
    {
        public class ArrayTypeMismatchException : SystemException
        {
            public ArrayTypeMismatchException();
            public ArrayTypeMismatchException(string message);
            public ArrayTypeMismatchException(string message,
            Exception innerException);
        }
    }
    namespace System
    {
        [AttributeUsageAttribute(AttributeTargets.All, Inherited = true,
        AllowMultiple = false)]
        public abstract class Attribute
        {
            protected Attribute();
        }
    }
    namespace System
    {
        public enum AttributeTargets
        {
            Assembly = 1,
            Module = 2,
            Class = 4,
            Struct = 8,
            Enum = 16,
            Constructor = 32,
            Method = 64,
            Property = 128,
            Field = 256,
            Event = 512,
            Interface = 1024,
            Parameter = 2048,
            Delegate = 4096,
            ReturnValue = 8192,
            GenericParameter = 16384,
            All = 32767
        }
    }
    namespace System
    {
        [AttributeUsageAttribute(AttributeTargets.Class, Inherited = true)]
        public sealed class AttributeUsageAttribute
        {
            public AttributeUsageAttribute(AttributeTargets validOn);
            public bool AllowMultiple { get; set; }
            public bool Inherited { get; set; }
            public AttributeTargets ValidOn { get; }
        }
    }
    namespace System
    {
        public struct Boolean
        {
        }
    }
    namespace System
    {
        public struct Byte
        {
        }
    }
    namespace System
    {
        public struct Char
        {
        }
    }
    namespace System
    {
        public struct Decimal
        {
        }
    }
    namespace System
    {
        public abstract class Delegate
        {
        }
    }
    namespace System
    {
        public class DivideByZeroException : ArithmeticException
        {
            public DivideByZeroException();
            public DivideByZeroException(string message);
            public DivideByZeroException(string message, Exception innerException);
        }
    }
    namespace System
    {
        public struct Double
        {
        }
    }
    namespace System
    {
        public abstract class Enum : ValueType
        {
            protected Enum();
        }
    }
    namespace System
    {
        public class Exception
        {
            public Exception();
            public Exception(string message);
            public Exception(string message, Exception innerException);
            public sealed Exception InnerException { get; }
            public virtual string Message { get; }
        }
    }
    namespace System
    {
        public interface IDisposable
        {
            public void Dispose();
        }
    }
    namespace System
    {
        public sealed class IndexOutOfRangeException : SystemException
        {
            public IndexOutOfRangeException();
            public IndexOutOfRangeException(string message);
            public IndexOutOfRangeException(string message,
            Exception innerException);
        }
    }
    namespace System
    {
        public struct Int16
        {
        }
    }
    namespace System
    {
        public struct Int32
        {
        }
    }
    namespace System
    {
        public struct Int64
        {
        }
    }
    namespace System
    {
        public class InvalidCastException : SystemException
        {
            public InvalidCastException();
            public InvalidCastException(string message);
            public InvalidCastException(string message, Exception innerException);
        }
    }
    namespace System
    {
        public class InvalidOperationException : SystemException
        {
            public InvalidOperationException();
            public InvalidOperationException(string message);
            public InvalidOperationException(string message,
            Exception innerException);
        }
    }
    namespace System
    {
        public abstract class MemberInfo
        {
            protected MemberInfo();
        }
    }
    namespace System
    {
        public class NotSupportedException : SystemException
        {
            public NotSupportedException();
            public NotSupportedException(string message);
            public NotSupportedException(string message, Exception innerException);
        }
    }
    namespace System
    {
        public struct Nullable<T>
        {
            public bool HasValue { get; }
            public T Value { get; }
        }
    }
    namespace System
    {
        public class NullReferenceException : SystemException
        {
            public NullReferenceException();
            public NullReferenceException(string message);
            public NullReferenceException(string message, Exception innerException);
        }
    }
    namespace System
    {
        public class Object
        {
            public Object();
            ~Object();
            public virtual bool Equals(object obj);
            public virtual int GetHashCode();
            public Type GetType();
            public virtual string ToString();
        }
    }
    namespace System
    {
        [AttributeUsageAttribute(AttributeTargets.Class
        | AttributeTargets.Struct
        | AttributeTargets.Enum | AttributeTargets.Interface
        | AttributeTargets.Constructor | AttributeTargets.Method
        | AttributeTargets.Property | AttributeTargets.Field
        | AttributeTargets.Event | AttributeTargets.Delegate,
        Inherited = false)]
        public sealed class ObsoleteAttribute : Attribute
        {
            public ObsoleteAttribute();
            public ObsoleteAttribute(string message);
            public ObsoleteAttribute(string message, bool error);
            public bool IsError { get; }
            public string Message { get; }
        }
    }
    namespace System
    {
        public class OutOfMemoryException : SystemException
        {
            public OutOfMemoryException();
            public OutOfMemoryException(string message);
            public OutOfMemoryException(string message, Exception innerException);
        }
    }
    namespace System
    {
        public class OverflowException : ArithmeticException
        {
            public OverflowException();
            public OverflowException(string message);
            public OverflowException(string message, Exception innerException);
        }
    }
    namespace System
    {
        public struct SByte
        {
        }
    }
    namespace System
    {
        public struct Single
        {
        }
    }
    namespace System
    {
        public sealed class StackOverflowException : SystemException
        {
            public StackOverflowException();
            public StackOverflowException(string message);
            public StackOverflowException(string message, Exception innerException);
        }
    }
    namespace System
    {
        using Collections;
        using Collections.Generic;
        public sealed class String : IEnumerable<Char>, IEnumerable
        {
            public int Length { get; }
            public char this[int index] { get; }
        }
    }
    namespace System
    {
        public class SystemException : Exception
        {
            public SystemException();
            public SystemException(string message);
            public SystemException(string message, Exception innerException);
        }
    }
    namespace System
    {
        public abstract class Type : MemberInfo
        {
        }
    }
    namespace System
    {
        public sealed class TypeInitializationException : SystemException
        {
            public TypeInitializationException(string fullTypeName,
            Exception innerException);
        }
    }
    namespace System
    {
        public struct UInt16
        {
        }
    }
    namespace System
    {
        public struct UInt32
        {
        }
    }
    namespace System
    {
        public struct UInt64
        {
        }
    }
    namespace System
    {
        public abstract class ValueType
        {
            protected ValueType();
        }
    }
    namespace System.Collections
    {
        public interface ICollection : IEnumerable
        {
            public int Count { get{return 0;} }
            public bool IsSynchronized { get; }
            public object SyncRoot { get; }
            public void CopyTo(Array array, int index);
        }
    }
    namespace System.Collections
    {
        public interface IEnumerable
        {
            public IEnumerator GetEnumerator();
        }
    }
    namespace System.Collections
    {
        public interface IEnumerator
        {
            public object Current { get; }
            public bool MoveNext();
            public void Reset();
        }
    }
    namespace System.Collections
    {
        public interface IList : ICollection, IEnumerable
        {
            public bool IsFixedSize { get; }
            public bool IsReadOnly { get; }
            public object this[int index] { get; set; }
            public int Add(object value);
            public void Clear();
            public bool Contains(object value);
            public int IndexOf(object value);
            public void Insert(int index, object value);
            public void Remove(object value);
            public void RemoveAt(int index);
        }
    }
    namespace System.Collections.Generic
    {
        public interface ICollection<T> : IEnumerable<T>
        {
            public int Count { get; }
            public bool IsReadOnly { get; }
            public void Add(T item);
            public void Clear();
            public bool Contains(T item);
            public void CopyTo(T[] array, int arrayIndex);
            public bool Remove(T item);
        }
    }
    namespace System.Collections.Generic
    {
        public interface IEnumerable<T> : IEnumerable
        {
            public IEnumerator<T> GetEnumerator();
        }
    }
    namespace System.Collections.Generic
    {
        public interface IEnumerator<T> : IDisposable, IEnumerator
        {
            public T Current { get; }
        }
    }
    namespace System.Collections.Generic
    {
        public interface IList<T> : ICollection<T>
        {
            public T this[int index] { get; set; }
            public int IndexOf(T item);
            public void Insert(int index, T item);
            public void RemoveAt(int index);
        }
    }
    namespace System.Diagnostics
    {
        [AttributeUsageAttribute(AttributeTargets.Method
        | AttributeTargets.Class, AllowMultiple = true)]
        public sealed class ConditionalAttribute : Attribute
        {
            public ConditionalAttribute(string conditionString);
            public string ConditionString { get; }
        }
    }
    namespace System.Threading
    {
        public static class Monitor
        {
            public static void Enter(object obj);
            public static void Exit(object obj);
        }
    }
#endif